home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 1997 #3 / Amiga Plus CD - 1997 - No. 03.iso / pd / demo-versionen / maxoncpp4-demo / demo / supercode / boopsi.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-01-01  |  20.7 KB  |  1,032 lines
  1. //-------------------------------------
  2. //
  3. // SuperCode (c) 1996 by T.Kühn 
  4. //
  5. // Programmiersprache:    ANSI-C
  6. // Projektstart:            7.9.94
  7. //
  8. // Modul:                Boopsi-Gadgets
  9. //
  10. //-------------------------------------
  11.  
  12.  
  13.  
  14. #include <stdarg.h>
  15. #include <pragma/intuition_lib.h>
  16. #include <pragma/dos_lib.h>
  17. #include <pragma/graphics_lib.h>
  18. #include <pragma/utility_lib.h>
  19. #include <pragma/gadtools_lib.h>
  20. #include <clib/alib_protos.h>
  21. #include <libraries/gadtools.h>
  22. #include <utility/hooks.h>
  23.  
  24. #include <intuition/gadgetclass.h>
  25. #include <intuition/icclass.h>
  26. #include <intuition/imageclass.h>
  27.  
  28. #pragma header
  29.  
  30. #include <Struct.h>
  31.  
  32.  
  33. void Class_Init(void);
  34. BOOL Class_Free(void);
  35.  
  36. Class *class_button=0;
  37. Class *class_text=0;
  38. Class *class_symbol=0;
  39.  
  40.  
  41. //-------------------------------------
  42. LONG Txt_DimX(struct RastPort *rp,UBYTE *String,ULONG Size)
  43. {
  44.     WORD Len;
  45.  
  46.     if (!Size) Size=strlen(String);
  47.  
  48.     Len=TextLength(rp,String,Size);
  49.  
  50.     return(Len);
  51. }
  52. //-------------------------------------
  53. LONG Txt_FitX(struct RastPort *rp,UBYTE *String,ULONG Size,ULONG Width,ULONG *newpixlen)
  54. {
  55.     struct TextExtent Te;
  56.     WORD len;
  57.  
  58.     if (String)
  59.     {
  60.         if (!Size) Size=strlen(String);
  61.     
  62.         len=TextFit(rp,String,Size,&Te,0,1,Width,1000);
  63.     
  64.         if (newpixlen) (*newpixlen)=Te.te_Width;
  65.     }
  66.     return(len);
  67. }
  68. //-------------------------------------
  69. VOID Txt_PrintFit(struct RastPort *rp,UBYTE *txt,ULONG n,ULONG x,ULONG y,ULONG w,ULONG h,ULONG fg,ULONG bg,ULONG flag)
  70. {
  71.     ULONG y2,np,pix=0;
  72.  
  73.     if (rp)
  74.     {
  75.         if (!h) h=rp->TxHeight;
  76.         if (txt && rp->TxHeight <= h)
  77.         {
  78.             LONG diff=0;
  79.             np=Txt_FitX(rp,txt,n,w,&pix);
  80.  
  81.             y2= y+(h-rp->TxHeight+1)/2+rp->TxBaseline;
  82.  
  83.             if (flag&BOX_RIGHT || flag&BOX_CENTER)
  84.             {
  85.                 diff=w-pix;
  86.                 if (flag&BOX_CENTER) diff/=2;
  87.                 if (flag&BOX_FILL)
  88.                 {
  89.                     SetAPen(rp,bg);
  90.                     RectFill(rp,x,y,x+diff,y+h-1);
  91.                 }
  92.             }
  93.         
  94.             SetDrMd(rp,JAM2);
  95.             SetBPen(rp,bg);
  96.             SetAPen(rp,fg);
  97.             Move(rp,x+diff,y2);
  98.             Text(rp,txt,np);
  99.     
  100.             if (!(flag&BOX_RIGHT))
  101.             {
  102.                 if (flag&BOX_FILL)
  103.                 {
  104.                     SetAPen(rp,bg);
  105.                     RectFill(rp,rp->cp_x,y,x+w-1,y+h-1);
  106.                 }
  107.             }
  108.         }
  109.         else
  110.         {
  111.             SetAPen(rp,bg);
  112.             RectFill(rp,x,y,x+w-1,y+h-1);
  113.         }
  114.     }
  115. }
  116. //-------------------------------------
  117.  
  118.  
  119. //-------------------------------------
  120. ULONG SetInfoAttrs(struct GadgetInfo *ginfo,struct Gadget *gad,ULONG data ...)
  121. {
  122.     ULONG back=0;
  123.  
  124.     if (gad)
  125.     {
  126.         if (ginfo)
  127.         {
  128.             back=SetGadgetAttrsA(gad,ginfo->gi_Window,ginfo->gi_Requester,(struct TagItem*)&data);
  129.         }
  130.         else
  131.         {
  132.             back=SetGadgetAttrsA(gad,0,0,(struct TagItem*)&data);
  133.         }
  134.     }
  135.     return back;
  136. }
  137. //-------------------------------------
  138. ULONG GadGetAttr(struct Gadget *gad,ULONG id)
  139. {
  140.     ULONG back=0;
  141.  
  142.     if (gad)
  143.     {
  144.         back=GetAttr(id,gad,&back);
  145.     }
  146.     return back;
  147. }
  148. //-------------------------------------
  149.  
  150. #define LEFT (-1)
  151. #define RGHT ( 1)
  152.  
  153. //-------------------------------------
  154. VOID DrawLineR(struct RastPort *rp,LONG rx,LONG ry,LONG x1,LONG y1,LONG x2,LONG y2,LONG col)
  155. {
  156.     LONG t=0;
  157.  
  158.     SetAPen(rp,col);
  159.  
  160.     if (rx>1)
  161.     {
  162.         for (t=rx-1;t>=0;t--)
  163.         {
  164.             Move(rp,x1+t,y1);
  165.             Draw(rp,x2+t,y2);
  166.         }
  167.     }
  168.     else if (ry>1)
  169.     {
  170.         for (t=ry-1;t>=0;t--)
  171.         {
  172.             Move(rp,x1,y1+t);
  173.             Draw(rp,x2,y2+t);
  174.         }
  175.     }
  176.     else
  177.     {
  178.         Move(rp,x1,y1);
  179.         Draw(rp,x2,y2);
  180.     }
  181.  
  182. }
  183. //-------------------------------------
  184. VOID DrawToR(struct RastPort *rp,LONG rx,LONG ry,LONG x2,LONG y2,LONG col)
  185. {
  186.     LONG x1,y1;
  187.  
  188.     x1=rp->cp_x;
  189.     y1=rp->cp_y;
  190.     
  191.     DrawLineR(rp,rx,ry,x1,y1,x2,y2,col);
  192. }
  193. //-------------------------------------
  194. VOID DrawBoxR(struct RastPort *rp,LONG rx,LONG ry,ULONG x,ULONG y,ULONG w,ULONG h,LONG c1,LONG c2)
  195. {
  196.     SetDrMd(rp,JAM1);
  197.  
  198.     DrawLineR(rp,rx,ry,x,y,x,y+h,c1);
  199.     DrawLineR(rp,rx,ry,x,y,x+w,y,c1);
  200.     DrawLineR(rp,rx,ry,x+w,y,x+w,y+h,c2);
  201.     DrawLineR(rp,rx,ry,x+w,y+h,x,y+h,c2);
  202.  
  203. }
  204. //-------------------------------------
  205. VOID DrawBox(struct RastPort *rp,struct DrawInfo *drinfo,ULONG x,ULONG y,ULONG w,ULONG h,BOOL Border)
  206. {
  207.     UWORD     *pens=drinfo->dri_Pens;
  208.     UWORD        c1,c2;
  209.  
  210. /*    LONG        rx=drinfo->dri_Resolution.X;
  211.     LONG        ry=drinfo->dri_Resolution.Y;
  212.     if (rx<ry)            { rx=ry/rx;ry=1; }
  213.     else if (rx>ry)    { ry=rx/ry;rx=1; }
  214.     else                    { rx=1;ry=1; }
  215. */
  216.     LONG        rx=2;
  217.     LONG        ry=1;
  218.  
  219.     w=w-rx;
  220.     h=h-ry;
  221.  
  222.     if (!Border)
  223.     {
  224.         c1=pens[SHINEPEN];
  225.         c2=pens[SHADOWPEN];
  226.     }
  227.     else
  228.     {
  229.         c1=pens[SHADOWPEN];
  230.         c2=pens[SHINEPEN];
  231.     }
  232.  
  233.     SetDrMd(rp,JAM1);
  234.  
  235.     DrawLineR(rp,rx,ry,x,y,x,y+h,c1);
  236.     DrawLineR(rp,rx,ry,x,y,x+w,y,c1);
  237.     DrawLineR(rp,rx,ry,x+w,y,x+w,y+h,c2);
  238.     DrawLineR(rp,rx,ry,x+w,y+h,x,y+h,c2);
  239.  
  240. }
  241. //-------------------------------------
  242.  
  243.  
  244. //-------------------------------------
  245. void Gadget_UpdateRender(Class *klasse,struct Gadget *gad,struct opUpdate *msg)
  246. {
  247.     struct GadgetInfo    *ginfo=msg->opu_GInfo;
  248.  
  249.     if (ginfo)
  250.     {
  251.         struct RastPort *rp=ObtainGIRPort(ginfo);
  252.         struct gpRender drmsg=
  253.         {
  254.             GM_RENDER,ginfo,rp,GREDRAW_UPDATE
  255.         };
  256.         if (rp)
  257.         {
  258.             DoMethodA((Object*)gad,(Msg)&drmsg);
  259.             ReleaseGIRPort(rp);
  260.         }
  261.     }
  262. }
  263. //-------------------------------------
  264.  
  265.  
  266. //-------------------------------------
  267. struct SymbolData
  268. {
  269.     ULONG                    special;
  270.     UBYTE                    col_bg,col_fg,sel_bg,sel_fg;
  271.     enum SymbolType     symbol;
  272. };
  273. //-------------------------------------
  274. BOOL  Gadget_SymbolHitTest(Class *klasse,struct Gadget *gad,struct gpHitTest *ht)
  275. {
  276.     BOOL back=FALSE;
  277.     WORD x=ht->gpht_Mouse.X;
  278.     WORD y=ht->gpht_Mouse.Y;
  279.  
  280.     WORD gw=gad->Width;
  281.     WORD gh=gad->Height;
  282.  
  283.     if (x>=0 && x<gw && y>=0 && y<gh ) back=GMR_GADGETHIT;
  284.  
  285.     return back;
  286. }
  287. //-------------------------------------
  288. ULONG Gadget_SymbolRender(Class *klasse,struct Gadget *gadget,struct gpRender *gp)
  289. {
  290.     struct SymbolData    *data=INST_DATA(klasse,gadget);
  291.  
  292.     struct GadgetInfo    *ginfo=gp->gpr_GInfo;
  293.     struct DrawInfo    *drinfo=ginfo->gi_DrInfo;
  294.     struct RastPort    *rp=ObtainGIRPort(ginfo);
  295.     UWORD                 *pens=drinfo->dri_Pens;
  296.  
  297.     LONG        fg,bg;
  298.     BOOL        Border=FALSE;
  299.     LONG        x,y,w,h;
  300.     LONG        dx=0,dy=0;
  301.  
  302.     LONG        rx=drinfo->dri_Resolution.X;
  303.     LONG        ry=drinfo->dri_Resolution.Y;
  304.  
  305.     LONG col_l=pens[SHINEPEN];
  306.     LONG col_d=pens[SHADOWPEN];
  307.  
  308.     if (rx<ry)            { rx=ry/rx;ry=1; }
  309.     else if (rx>ry)    { ry=rx/ry;rx=1; }
  310.     else                    { rx=1;ry=1; }
  311.  
  312.     x=gadget->LeftEdge;
  313.     y=gadget->TopEdge;
  314.  
  315.     w=gadget->Width;
  316.     h=gadget->Height;
  317.  
  318.     if (!(gadget->Flags & GFLG_SELECTED))
  319.     {
  320.         fg=pens[data->col_fg];
  321.         bg=pens[data->col_bg];
  322.     }
  323.     else
  324.     {
  325.         if (data->symbol != SYMBOL_CHECKPOINT)
  326.         {
  327.             dx=1;
  328.             dy=1;
  329.         }
  330.         Border=1-Border;
  331.         fg=pens[data->sel_fg];
  332.         bg=pens[data->sel_bg];
  333.     }
  334.  
  335.     SetAPen(rp,bg);
  336.     RectFill( rp,x,y,x+w-1,y+h-1);
  337.     DrawBox(rp,drinfo,x,y,w,h,Border);
  338.  
  339.     x+=dx;
  340.     y+=dy;
  341.  
  342.     dx=w*16/100;
  343.     dy=h*16/100;
  344.  
  345.     if (dx<rx) dx=rx;
  346.     if (dy<ry) dy=ry;
  347.  
  348.     x+=dx;
  349.     y+=dy;
  350.     w-=2*dx+rx;
  351.     h-=2*dy+ry;
  352.  
  353.     SetDrMd(rp,JAM1);
  354.     SetAPen(rp,fg);
  355.  
  356.     switch(data->symbol)
  357.     {
  358.         case SYMBOL_FONTREQUEST:
  359.             {
  360.                 LONG a,b;
  361.  
  362.                 dx=w/4;
  363.                 dy=h/4;
  364.  
  365.                 a=y+h-dy;
  366.  
  367.                 DrawLineR(rp,rx,ry, x,y,x+w-dx,y,col_d);
  368.                 DrawLineR(rp,rx,ry, x+dx/2,y,x+dx/2,a,col_d);
  369.                 a=(a-y)/2;
  370.                 DrawLineR(rp,rx,ry, x,y+a,x+2*dx,y+a,col_d);
  371.  
  372.                 a=a/2;
  373.                 b=dx;
  374.                 DrawLineR(rp,rx,ry, x+b,y+a,x+w,y+a,col_l);
  375.                 b=w-((w-b)/2);
  376.                 DrawLineR(rp,rx,ry, x+b,y+a,x+b,y+h,col_l);
  377.             }
  378.             break;
  379.         case SYMBOL_FILEREQUEST:
  380.             {
  381.                 LONG t;
  382.                 dx=w/4;
  383.                 dy=h/4;
  384.  
  385.                 DrawLineR(rp,rx,ry, x,y+h,x,y+dy,col_l);
  386.                 DrawToR(rp,rx,ry, x+dx,y,col_l);
  387.                 DrawToR(rp,rx,ry, x+w,y,col_l);
  388.  
  389.                 DrawToR(rp,rx,ry, x+w,y+h,col_d);
  390.                 DrawToR(rp,rx,ry, x+rx,y+h,col_d);
  391.  
  392.                 for (t=0;t<3;t++,y+=dy)
  393.                 {
  394.                     DrawLineR(rp,rx,ry, x+dx,y+dy,x+w-dx,y+dy, col_d);
  395.                     DrawLineR(rp,rx,ry, x+dx,y+dy+1,x+w-dx,y+dy+1, col_l);
  396.                 }
  397.             }
  398.             break;
  399.         case SYMBOL_SCRNMODEREQUEST:
  400.             {
  401.                 LONG xa,ya,wa,ha;
  402.  
  403.                 dy=h/8;
  404.                 dx=w/8;
  405.  
  406.                 xa=x;
  407.                 ya=y;
  408.                 wa=w;
  409.                 ha=h-2*dy;
  410.  
  411.                 DrawBoxR(rp,rx,ry,xa,ya,wa,ha,col_l,col_d);
  412.                 DrawBoxR(rp,rx,ry,xa+2,ya+ha+1,wa-4,h-ha-1,col_l,col_d);
  413.  
  414.                 dy=h/5;
  415.                 dx=w/5;
  416.                 DrawLineR(rp,rx,ry, xa+2*dx,y+dy,xa+dx,y+dy, col_l);
  417.                 DrawToR  (rp,rx,ry, xa+dx,y+2*dy ,col_l);
  418.                 DrawLineR(rp,rx,ry, xa+wa-2*dx,ya+ha-dy,xa+wa-dx,ya+ha-dy, col_d);
  419.                 DrawToR  (rp,rx,ry, xa+wa-dx,ya+ha-2*dy ,col_d);
  420.             }
  421.             break;
  422.         case SYMBOL_PUBSCRNREQUEST:
  423.             {
  424.                 LONG xa,ya,wa,ha;
  425.  
  426.                 dy=h/8;
  427.                 dx=w/8;
  428.  
  429.                 xa=x;
  430.                 ya=y;
  431.                 wa=w;
  432.                 ha=h;
  433.  
  434.                 DrawBoxR(rp,rx,ry,xa,ya,wa,ha,col_l,col_d);
  435.  
  436.                 dy=h/5;
  437.                 dx=w/5;
  438.                 DrawBoxR(rp,rx,ry, xa+w-rx-dx,ya,dx,dy,col_l,col_l);
  439.                 DrawLineR(rp,rx,ry, xa+rx,ya+dy,xa+w-(rx+dx),ya+dy, col_l);
  440.             }
  441.             break;
  442.         case SYMBOL_ARROWUP:
  443.         case SYMBOL_ARROWDOWN:
  444.         case SYMBOL_ARROWLEFT:
  445.         case SYMBOL_ARROWRIGHT:
  446.             {
  447.                 LONG w2=w/2;
  448.                 LONG h2=h/2;
  449.  
  450.                 dx=w/8;
  451.                 dy=h/8;
  452.                 if (dx<rx) dx=rx;
  453.                 if (dy<ry) dy=ry;
  454.  
  455.                 switch(data->symbol)
  456.                 {
  457.                     case SYMBOL_ARROWUP:
  458.                         DrawLineR(rp,rx,ry, x+w-dx,y+h-dy,x+w2,y+dy,col_l);
  459.                         DrawToR  (rp,rx,ry, x+dx,y+h-dy,col_d);
  460.                         break;
  461.                     case SYMBOL_ARROWDOWN:
  462.                         DrawLineR(rp,rx,ry, x+w-dx,y+dy,x+w2,y+h-dy,col_d);
  463.                         DrawToR  (rp,rx,ry, x+dx,y+dy,col_l);
  464.                         break;
  465.                     case SYMBOL_ARROWLEFT:
  466.                         DrawLineR(rp,rx,ry, x+w-dx,y+h-dy,x+dx,y+h2,col_d);
  467.                         DrawToR  (rp,rx,ry, x+w-dx,y+dy,col_l);
  468.                         break;
  469.                     case SYMBOL_ARROWRIGHT:
  470.                         DrawLineR(rp,rx,ry, x+dx,y+h-dy,x+w-dx,y+h2,col_d);
  471.                         DrawToR  (rp,rx,ry, x+dx,y+dy,col_l);
  472.                         break;
  473.                 }
  474.             }
  475.             break;
  476.         case SYMBOL_CHECKPOINT:
  477.             {
  478.                 LONG w2=w/2;
  479.                 LONG h2=h/2;
  480.  
  481.                 if (gadget->Flags & GFLG_SELECTED)
  482.                 {
  483.                     dx=w/8;
  484.                     dy=h/8;
  485.                     if (dx<rx) dx=rx;
  486.                     if (dy<ry) dy=ry;
  487.     
  488.                     DrawLineR(rp,rx,ry, x+dx,y+h2,x+w*2/5,y+h-dy,col_d);
  489.                     DrawToR  (rp,rx,ry, x+w-dx,y+dy,col_d);
  490.                 }
  491.             }
  492.             break;
  493.  
  494.     }
  495.  
  496.     if (rp) ReleaseGIRPort(rp);
  497.  
  498.     return TRUE;
  499. }
  500. //-------------------------------------
  501. ULONG Gadget_SymbolSetAttrs(Class *klasse,struct Gadget *obj, struct opSet *msg)
  502. {
  503.     struct SymbolData *data=INST_DATA(klasse,obj);
  504.     struct TagItem *tags=msg->ops_AttrList,*tbegin=tags,*tag;
  505.     ULONG tdata,back=FALSE;
  506.  
  507.     while( (tag=NextTagItem(&tbegin)) )
  508.     {
  509.         tdata=tag->ti_Data;
  510.         switch (tag->ti_Tag)
  511.         {
  512.             case GA_Special:
  513.                 data->special=tdata;
  514.                 break;
  515.             case GA_Symbol:
  516.                 if (data->symbol!=tdata)
  517.                 {
  518.                     data->symbol=(enum SymbolType)tdata;
  519.                     back=TRUE;
  520.                 }
  521.                 break;
  522.         }
  523.     }
  524.  
  525.     return back;
  526. }
  527. //-------------------------------------
  528. ULONG Gadget_SymbolGetAttr(Class *klasse,struct Gadget *gad, struct opGet *get)
  529. {
  530.     struct SymbolData *data=INST_DATA(klasse,gad);
  531.     ULONG *get_store=get->opg_Storage;
  532.     ULONG back=FALSE;
  533.  
  534.     if (get_store)
  535.     {
  536.         switch(get->opg_AttrID)
  537.         {
  538.             case GA_Special:
  539.                 (*get_store)=(ULONG)data->special;
  540.                 back=TRUE;
  541.                 break;
  542.             default:
  543.                 back=(ULONG)DoSuperMethodA(klasse,(Object*)gad,(Msg)get);
  544.                 break;
  545.         }
  546.     }
  547.  
  548.     return back;
  549. }
  550. //-------------------------------------
  551. ULONG Gadget_SymbolNotify(Class *klasse,struct Gadget *gad, struct opUpdate *msg)
  552. {
  553.     struct SymbolData *data=INST_DATA(klasse,gad);
  554.     LONG back=FALSE;
  555.     struct TagItem *tags=msg->opu_AttrList,*tbegin=tags,*tag;
  556.     ULONG tdata,num=0;
  557.  
  558.     while( (tag=NextTagItem(&tbegin)) )
  559.     {
  560.         num++;
  561.  
  562.         tdata=tag->ti_Data;
  563.         switch (tag->ti_Tag)
  564.         {
  565.             case GA_Special:
  566. //                tag->ti_Data
  567. //                data->special=tdata;
  568.                 back=TRUE;
  569.                 break;
  570.         }
  571.     }
  572.  
  573.     return back;
  574. }
  575. //-------------------------------------
  576. ULONG Gadget_SymbolDispatcher( Class *klasse, struct Gadget *obj, Msg msg)
  577. {
  578.     struct SymbolData *data=0;
  579.     ULONG back=0;
  580.  
  581.     switch (msg->MethodID)
  582.     {
  583.         case OM_NEW:
  584.             back=DoSuperMethodA(klasse, (Object*)obj, msg);
  585.             obj=(struct Gadget*)back;
  586.             if (back)
  587.             {
  588.                 data=INST_DATA(klasse,back);
  589.                 data->symbol=SYMBOL_NONE;
  590.  
  591.                 data->col_bg=BACKGROUNDPEN;
  592.                 data->col_fg=TEXTPEN;
  593.                 data->sel_bg=FILLPEN;
  594.                 data->sel_fg=FILLTEXTPEN;
  595.  
  596.                 Gadget_SymbolSetAttrs(klasse,(struct Gadget*)back,(struct opSet*)msg);
  597.             }
  598.             break;
  599.         case OM_GET:
  600.             back=Gadget_SymbolGetAttr(klasse,obj,(struct opGet*)msg);
  601.             break;
  602. //        case OM_NOTIFY:
  603. //            back=Gadget_SymbolNotify(klasse,obj,(struct opUpdate*)msg);
  604. //            break;
  605.         case OM_UPDATE:
  606.         case OM_SET:
  607.             back=DoSuperMethodA(klasse,(Object*)obj,msg);
  608.             back+=Gadget_SymbolSetAttrs(klasse,obj,(struct opSet*)msg);
  609.             if (back) Gadget_UpdateRender(klasse,obj,(struct opUpdate*)msg);
  610.             break;
  611.         case GM_RENDER:
  612.             Gadget_SymbolRender(klasse,obj,(struct gpRender*)msg);
  613.             break;
  614.         case GM_HITTEST:
  615.             back=Gadget_SymbolHitTest(klasse,obj,(struct gpHitTest*)msg);
  616.             break;
  617.         default:
  618.             back=DoSuperMethodA(klasse,(Object*)obj,msg);
  619.             break;
  620.     }
  621.  
  622. //    SetGInfoAttrs(gad_debug1,GA_Integer,msg->MethodID,TAG_END);
  623.  
  624. //    data=INST_DATA(klasse,obj);
  625. //    SetGInfoAttrs(gad_debug1,GA_Integer,data->special,TAG_END);
  626.  
  627.     return back;
  628. }
  629. //-------------------------------------
  630.  
  631.  
  632. //-------------------------------------
  633. struct ButtonData
  634. {
  635.     UBYTE        *Text;
  636.     UBYTE        col_bg,col_fg,sel_bg,sel_fg;
  637.     struct    TextFont *font;
  638. };
  639. //-------------------------------------
  640. BOOL  Gadget_ButtonHitTest(Class *klasse,struct Gadget *gad,struct gpHitTest *ht)
  641. {
  642.     BOOL back=FALSE;
  643.     WORD x=ht->gpht_Mouse.X;
  644.     WORD y=ht->gpht_Mouse.Y;
  645.  
  646.     WORD gw=gad->Width;
  647.     WORD gh=gad->Height;
  648.  
  649.     if (x>=0 && x<gw && y>=0 && y<gh ) back=GMR_GADGETHIT;
  650.  
  651.     return back;
  652. }
  653. //-------------------------------------
  654. ULONG Gadget_ButtonRender(Class *klasse,struct Gadget *gadget,struct gpRender *gp)
  655. {
  656.     struct ButtonData    *data=INST_DATA(klasse,gadget);
  657.     struct GadgetInfo    *ginfo=gp->gpr_GInfo;
  658.     struct DrawInfo    *drinfo=ginfo->gi_DrInfo;
  659.     struct RastPort    *rp=ObtainGIRPort(ginfo);
  660.     struct TextFont    *font=rp->Font;
  661.     UWORD                 *pens=drinfo->dri_Pens;
  662.     UBYTE                    *text=(UBYTE*)data->Text;
  663.  
  664.     LONG        fg,bg;
  665.     WORD        left,top,height=0,width=0,dx=0,dy=0;
  666.     BOOL        Border=FALSE;
  667.  
  668.     if (data->font)
  669.     {
  670.         font=data->font;
  671.         SetFont(rp,font);
  672.     }
  673.  
  674.     left=gadget->LeftEdge;
  675.     top =gadget->TopEdge;
  676.  
  677.     width=gadget->Width;
  678.     height=gadget->Height;
  679.  
  680.     if (!(gadget->Flags & GFLG_SELECTED))
  681.     {
  682.         fg=pens[data->col_fg];
  683.         bg=pens[data->col_bg];
  684.     }
  685.     else
  686.     {
  687.         dx=1;dy=1;
  688.         Border=1-Border;
  689.         fg=pens[data->sel_fg];
  690.         bg=pens[data->sel_bg];
  691.     }
  692.  
  693.     DrawBox(rp,drinfo,left,top,width,height,Border);
  694.  
  695.     left+=2;
  696.     top+=1;
  697.     width-=4;
  698.     height-=2;
  699.  
  700.     width--;
  701.     height--;
  702.  
  703.     SetAPen(rp,bg);
  704.     RectFill( rp,left,top,left+width,top+height);
  705.  
  706.  
  707.     if (text)
  708.     {
  709.         left+=dx;
  710.         top+=dy;
  711.  
  712.         Txt_PrintFit(rp,text,0,left,top,width,height,fg,bg,BOX_CENTER);
  713.     }
  714.  
  715.     if (rp) ReleaseGIRPort(rp);
  716.  
  717.     return TRUE;
  718. }
  719. //-------------------------------------
  720. ULONG Gadget_ButtonSetAttrs(Class *klasse,struct Gadget *obj, struct opSet *msg)
  721. {
  722.     struct ButtonData *data=INST_DATA(klasse,obj);
  723.     struct TagItem *tags=msg->ops_AttrList,*tbegin=tags,*tag;
  724.     ULONG tdata,back=FALSE;
  725.  
  726.     while( (tag=NextTagItem(&tbegin)) )
  727.     {
  728.         tdata=tag->ti_Data;
  729.         switch (tag->ti_Tag)
  730.         {
  731.             case GA_Font:
  732.                 if (data->font!=(struct TextFont*)tdata)
  733.                 {
  734.                     data->font=(struct TextFont*)tdata;
  735.                     back=TRUE;
  736.                 }
  737.                 break;
  738.             case GA_Text:
  739.                 if (!data->Text || !tdata || 0!=strcmp(data->Text,(UBYTE*)tdata))
  740.                 {
  741.                     data->Text=(UBYTE*)tdata;
  742.                     back=TRUE;
  743.                 }
  744.                 break;
  745.             case GA_TextCol:
  746.                 if (data->col_fg!=tdata)
  747.                 {
  748.                     data->col_fg=tdata;
  749.                     back=TRUE;
  750.                 }
  751.                 break;
  752.         }
  753.     }
  754.  
  755.     return back;
  756. }
  757. //-------------------------------------
  758. ULONG Gadget_ButtonDispatcher( Class *klasse, struct Gadget *obj, Msg msg)
  759. {
  760.     struct ButtonData *data;
  761.     ULONG back=0;
  762.  
  763.     switch (msg->MethodID)
  764.     {
  765.         case OM_NEW:
  766.             back=DoSuperMethodA(klasse, (Object*)obj, msg);
  767.             if (back)
  768.             {
  769.                 struct TagItem *tt=((struct opSet*)msg)->ops_AttrList;
  770.                 struct DrawInfo *drinfo=(struct DrawInfo*)GetTagData(SYSIA_DrawInfo,NULL,tt);
  771.  
  772.                 data=INST_DATA(klasse,back);
  773.                 data->Text=0;
  774.  
  775.                 data->col_bg=BACKGROUNDPEN;
  776.                 data->col_fg=TEXTPEN;
  777.                 data->sel_bg=FILLPEN;
  778.                 data->sel_fg=FILLTEXTPEN;
  779.                 data->font=0;
  780.  
  781.                 Gadget_ButtonSetAttrs(klasse,(struct Gadget*)back,(struct opSet*)msg);
  782.             }
  783.             break;
  784.         case OM_UPDATE:
  785.         case OM_SET:
  786.             back=DoSuperMethodA(klasse,(Object*)obj,msg);
  787.             back+=Gadget_ButtonSetAttrs(klasse,obj,(struct opSet*)msg);
  788.             if (back) Gadget_UpdateRender(klasse,obj,(struct opUpdate*)msg);
  789.             break;
  790.         case GM_RENDER:
  791.             Gadget_ButtonRender(klasse,obj,(struct gpRender*)msg);
  792.             break;
  793.         case GM_HITTEST:
  794.             back=Gadget_ButtonHitTest(klasse,obj,(struct gpHitTest*)msg);
  795.             break;
  796.         default:
  797.             back=DoSuperMethodA(klasse,(Object*)obj,msg);
  798.             break;
  799.     }
  800.     return back;
  801. }
  802. //-------------------------------------
  803.  
  804.  
  805. //-------------------------------------
  806. struct TextData
  807. {
  808.     UBYTE        *text;
  809.     LONG        integer;
  810.     BOOL        text_border;
  811.     ULONG        text_just;
  812.     ULONG        col_fg;
  813.     ULONG        col_bg;
  814.     struct    TextFont *font;
  815. };
  816. //-------------------------------------
  817. ULONG Gadget_TextRender(Class *klasse,struct Gadget *gad,struct gpRender *gp)
  818. {
  819.     struct TextData        *data=INST_DATA(klasse,gad);
  820.     struct GadgetInfo        *ginfo=gp->gpr_GInfo;
  821.     struct Window            *win=ginfo->gi_Window;
  822.     struct DrawInfo        *drinfo=ginfo->gi_DrInfo;
  823.     struct RastPort        *rp=ObtainGIRPort(ginfo);
  824.     struct TextFont        *font=rp->Font;
  825.     UWORD                        *pens=drinfo->dri_Pens;
  826.  
  827.     LONG fg=pens[data->col_fg],bg=pens[data->col_bg];
  828.     LONG x,y,w,h;
  829.  
  830.     if (data->font)
  831.     {
  832.         font=data->font;
  833.         SetFont(rp,font);
  834.     }
  835.  
  836.     x=gad->LeftEdge;
  837.     y=gad->TopEdge;
  838.     w=gad->Width;
  839.     h=gad->Height;
  840.  
  841.     DrawBox(rp,drinfo,x,y,w,h,data->text_border);
  842.     SetAPen(rp,bg);
  843.     RectFill(rp,x+2,y+1,x+w-4,y+h-2);
  844.  
  845.     x+=4;
  846.     w-=8;
  847.     y+=2;
  848.     h-=4;
  849.  
  850.     if (data->text)
  851.     {
  852.         Txt_PrintFit(rp,data->text,0,x,y,w,h,fg,bg,data->text_just);
  853.     }
  854.  
  855.     if (rp) ReleaseGIRPort(rp);
  856.  
  857.     return FALSE;
  858. }
  859. //-------------------------------------
  860. ULONG Gadget_TextSetAttrs(Class *klasse,struct Gadget *gad, struct opSet *msg)
  861. {
  862.     struct TextData    *data=INST_DATA(klasse,gad);
  863.     struct GadgetInfo    *ginfo=msg->ops_GInfo;
  864.     struct TagItem        *tags=msg->ops_AttrList,*tbegin=tags,*tag;
  865.     ULONG                 tdata,back=FALSE;
  866.  
  867.     while( (tag=NextTagItem(&tbegin)) )
  868.     {
  869.         tdata=tag->ti_Data;
  870.         switch (tag->ti_Tag)
  871.         {
  872.             case GA_Integer:
  873.                 if (tdata!=data->integer)
  874.                 {
  875.                     data->integer=tdata;
  876.                     if (data->text) Memory_Free(&data->text);
  877.                     data->text=(UBYTE*)Memory_Alloc(100);
  878.                     if (data->text) sprintf(data->text,"%d",tdata);
  879.                     back=TRUE;
  880.                 }
  881.                 break;
  882.             case GA_Text:
  883.                 if (tdata==0 || data->text==0 || 0!=strcmp(data->text,(char*)tdata))
  884.                 {
  885.                     if (data->text) Memory_Free(&data->text);
  886.                     if (tdata)
  887.                     {
  888.                         ULONG l=strlen((char*)tdata);
  889.                         if (tdata) data->text=(UBYTE*)Memory_Alloc(l+2);
  890.                         if (data->text)
  891.                         {
  892.                             strncpy(data->text,(char*)tdata,l);
  893.                             data->text[l+1]=0;
  894.                         }
  895.                     }
  896.                     back=TRUE;
  897.                 }
  898.                 break;
  899.             case GA_TextJust:
  900.                 if (data->text_just!=tdata)
  901.                 {
  902.                     data->text_just=tdata;
  903.                     back=TRUE;
  904.                 }
  905.                 break;
  906.             case GA_TextCol:
  907.                 if (data->col_fg!=tdata)
  908.                 {
  909.                     data->col_fg=tdata;
  910.                     back=TRUE;
  911.                 }
  912.                 break;
  913.             case GA_BoxCol:
  914.                 if (data->col_bg!=tdata)
  915.                 {
  916.                     data->col_bg=tdata;
  917.                     back=TRUE;
  918.                 }
  919.                 break;
  920.             case GA_BoxBorder:
  921.                 if (data->text_border!=tdata)
  922.                 {
  923.                     data->text_border=tdata;
  924.                     back=TRUE;
  925.                 }
  926.                 break;
  927.             case GA_Font:
  928.                 if (data->font!=(struct TextFont*)tdata)
  929.                 {
  930.                     data->font=(struct TextFont*)tdata;
  931.                     back=TRUE;
  932.                 }
  933.                 break;
  934.         }
  935.     }
  936.     return back;
  937.  
  938. }
  939. //-------------------------------------
  940. ULONG Gadget_TextDispatcher( Class *klasse, struct Gadget *obj, Msg msg)
  941. {
  942.     struct TextData *data;
  943.     ULONG back=0;
  944.  
  945.     switch (msg->MethodID)
  946.     {
  947.         case OM_NEW:
  948.             back = DoSuperMethodA(klasse, (Object*)obj, msg);
  949.             if (back)
  950.             {
  951.                 obj=(struct Gadget*)back;
  952.  
  953.                 data=INST_DATA(klasse,obj);
  954.                 data->col_bg=BACKGROUNDPEN;
  955.                 data->col_fg=TEXTPEN;
  956.                 data->text_border=TRUE;
  957.                 data->text_just=BOX_LEFT;
  958.                 data->font=0;
  959.                 data->integer=0;
  960.                 data->text=0;
  961.  
  962.                 Gadget_TextSetAttrs(klasse,obj,(struct opSet*)msg);    
  963.             }
  964.             break;
  965.         case OM_DISPOSE:
  966.             data=INST_DATA(klasse,obj);
  967.             if (data->text) Memory_Free(&data->text);
  968.             DoSuperMethodA(klasse,(Object*)obj,msg);
  969.             break;
  970.         case OM_UPDATE:
  971.         case OM_SET:
  972.             back+=DoSuperMethodA(klasse,(Object*)obj,msg);
  973.             back+=Gadget_TextSetAttrs(klasse,obj,(struct opSet*)msg);    
  974.             if (back) Gadget_UpdateRender(klasse,obj,(struct opUpdate*)msg);
  975.             break;
  976.         case GM_RENDER:
  977.             DoSuperMethodA(klasse,(Object*)obj,msg);
  978.             Gadget_TextRender(klasse,obj,(struct gpRender *)msg);
  979.         default:
  980.             back=DoSuperMethodA(klasse,(Object*)obj,msg);
  981.             break;
  982.     }
  983.  
  984.     return back;
  985. }
  986. //-------------------------------------
  987.  
  988.  
  989. //-------------------------------------
  990. void Class_Make(Class **klasse,ClassID id,ClassID superid,struct IClass *superclass,ULONG size,
  991.                     ULONG flags,VOID *func)
  992. {
  993.     extern ULONG HookEntry();
  994.  
  995.     do    {    (*klasse)=MakeClass(id,superid,superclass,size,flags);
  996.         }    while((!(*klasse)) && ASK_AGAIN==display_error(ERR_CREATECLASS,ASK_EXIT|ASK_AGAIN));
  997.  
  998.     if (*klasse)
  999.     {
  1000.         (*klasse)->cl_Dispatcher.h_Entry=HookEntry;
  1001.         (*klasse)->cl_Dispatcher.h_SubEntry=(VOID*)func;
  1002.     }
  1003. }
  1004. //-------------------------------------
  1005. void Class_Close(Class **klasse)
  1006. {
  1007.     if (*klasse) FreeClass(*klasse);
  1008.     (*klasse)=0;
  1009. }
  1010. //-------------------------------------
  1011.  
  1012.  
  1013.  
  1014. //-------------------------------------
  1015. void Class_Init()
  1016. {
  1017.     Class_Make(&class_button    ,NULL,BUTTONGCLASS,NULL,sizeof(struct ButtonData),0,(VOID*)Gadget_ButtonDispatcher),
  1018.     Class_Make(&class_text      ,NULL,GADGETCLASS ,NULL,sizeof(struct TextData  ),0,(VOID*)Gadget_TextDispatcher);
  1019.     Class_Make(&class_symbol    ,NULL,BUTTONGCLASS,NULL,sizeof(struct SymbolData),0,(VOID*)Gadget_SymbolDispatcher);
  1020. }
  1021. //-------------------------------------
  1022. BOOL Class_Free()
  1023. {
  1024.     Class_Close(&class_symbol);
  1025.     Class_Close(&class_text);
  1026.     Class_Close(&class_button);
  1027.  
  1028.     return(TRUE);
  1029. }
  1030. //-------------------------------------
  1031.  
  1032.